home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Contributed / SpriteWorld / SpriteWorld Files / BlitPixie / Sources / BlitPixieRotoZoomer.c < prev    next >
Encoding:
Text File  |  2000-10-06  |  19.6 KB  |  769 lines  |  [TEXT/CWIE]
  1. ///--------------------------------------------------------------------------------------
  2. //    BlitPixieRotoZoomer
  3. //            a rotation/zoom blitter
  4. //
  5. //    written by Anders F Björklund <afb@algonet.se>
  6. //    © 1999 afb.
  7. ///--------------------------------------------------------------------------------------
  8.  
  9. #ifndef __BLITPIXIE__
  10. #include "BlitPixieHeader.h"
  11. #endif
  12.  
  13. #ifndef GENERATINGASM // do not include for asm file generation
  14.  
  15. static Boolean log2(long x,long *bit);
  16.  
  17. /*
  18.     trig tables : sintable[360], costable[360] in 16.16 fixed point format
  19.  
  20. */
  21.  
  22. static long trigtable[360 + 90] =
  23. { 
  24.           +0,   +1143,   +2287,   +3429,   +4571,   +5711,   +6850,   +7986,
  25.        +9120,  +10251,  +11380,  +12504,  +13625,  +14742,  +15854,  +16961,
  26.       +18063,  +19160,  +20251,  +21336,  +22414,  +23485,  +24549,  +25606,
  27.       +26655,  +27696,  +28728,  +29752,  +30766,  +31771,  +32767,  +33753,
  28.       +34728,  +35692,  +36646,  +37589,  +38520,  +39439,  +40347,  +41242,
  29.       +42125,  +42994,  +43851,  +44694,  +45524,  +46340,  +47141,  +47929,
  30.       +48702,  +49459,  +50202,  +50930,  +51642,  +52338,  +53018,  +53683,
  31.       +54330,  +54962,  +55576,  +56174,  +56754,  +57318,  +57863,  +58392,
  32.       +58902,  +59394,  +59869,  +60325,  +60763,  +61182,  +61582,  +61964,
  33.       +62327,  +62671,  +62996,  +63301,  +63588,  +63855,  +64102,  +64330,
  34.       +64539,  +64728,  +64897,  +65046,  +65175,  +65285,  +65375,  +65445,
  35.       +65495,  +65525,  +65534,  +65525,  +65495,  +65445,  +65375,  +65285,
  36.       +65175,  +65046,  +64897,  +64728,  +64539,  +64330,  +64102,  +63855,
  37.       +63588,  +63301,  +62996,  +62671,  +62327,  +61964,  +61582,  +61182,
  38.       +60762,  +60325,  +59869,  +59394,  +58902,  +58392,  +57863,  +57318,
  39.       +56754,  +56174,  +55576,  +54962,  +54330,  +53683,  +53018,  +52338,
  40.       +51642,  +50930,  +50202,  +49459,  +48702,  +47929,  +47141,  +46340,
  41.       +45524,  +44694,  +43851,  +42994,  +42125,  +41242,  +40347,  +39440,
  42.       +38520,  +37589,  +36646,  +35693,  +34728,  +33753,  +32767,  +31772,
  43.       +30766,  +29752,  +28728,  +27696,  +26655,  +25606,  +24550,  +23485,
  44.       +22414,  +21336,  +20251,  +19160,  +18064,  +16961,  +15854,  +14742,
  45.       +13625,  +12504,  +11380,  +10252,   +9120,   +7986,   +6850,   +5712,
  46.        +4571,   +3430,   +2287,   +1144,      +0,   -1143,   -2286,   -3429,
  47.        -4571,   -5711,   -6849,   -7986,   -9120,  -10251,  -11379,  -12504,
  48.       -13625,  -14741,  -15853,  -16961,  -18063,  -19160,  -20251,  -21335,
  49.       -22413,  -23485,  -24549,  -25606,  -26655,  -27695,  -28728,  -29751,
  50.       -30766,  -31771,  -32767,  -33752,  -34727,  -35692,  -36646,  -37588,
  51.       -38520,  -39439,  -40346,  -41242,  -42124,  -42994,  -43851,  -44694,
  52.       -45523,  -46339,  -47141,  -47928,  -48701,  -49459,  -50202,  -50929,
  53.       -51641,  -52338,  -53018,  -53682,  -54330,  -54961,  -55576,  -56174,
  54.       -56754,  -57317,  -57863,  -58391,  -58902,  -59394,  -59868,  -60324,
  55.       -60762,  -61181,  -61582,  -61964,  -62327,  -62671,  -62996,  -63301,
  56.       -63588,  -63855,  -64102,  -64330,  -64539,  -64728,  -64897,  -65046,
  57.       -65175,  -65285,  -65375,  -65445,  -65495,  -65525,  -65534,  -65525,
  58.       -65495,  -65445,  -65375,  -65285,  -65176,  -65046,  -64897,  -64728,
  59.       -64539,  -64331,  -64103,  -63855,  -63588,  -63302,  -62996,  -62671,
  60.       -62327,  -61964,  -61583,  -61182,  -60763,  -60325,  -59869,  -59395,
  61.       -58902,  -58392,  -57864,  -57318,  -56755,  -56175,  -55577,  -54962,
  62.       -54331,  -53683,  -53019,  -52339,  -51642,  -50930,  -50203,  -49460,
  63.       -48702,  -47930,  -47142,  -46341,  -45525,  -44695,  -43852,  -42995,
  64.       -42126,  -41243,  -40348,  -39440,  -38521,  -37590,  -36647,  -35693,
  65.       -34729,  -33754,  -32768,  -31773,  -30767,  -29753,  -28729,  -27697,
  66.       -26656,  -25607,  -24551,  -23486,  -22415,  -21337,  -20252,  -19161,
  67.       -18065,  -16963,  -15855,  -14743,  -13626,  -12506,  -11381,  -10253,
  68.        -9122,   -7988,   -6851,   -5713,   -4572,   -3431,   -2288,   -1145
  69.  
  70.             // table repeats, for the costable
  71.           +0,   +1143,   +2287,   +3429,   +4571,   +5711,   +6850,   +7986,
  72.        +9120,  +10251,  +11380,  +12504,  +13625,  +14742,  +15854,  +16961,
  73.       +18063,  +19160,  +20251,  +21336,  +22414,  +23485,  +24549,  +25606,
  74.       +26655,  +27696,  +28728,  +29752,  +30766,  +31771,  +32767,  +33753,
  75.       +34728,  +35692,  +36646,  +37589,  +38520,  +39439,  +40347,  +41242,
  76.       +42125,  +42994,  +43851,  +44694,  +45524,  +46340,  +47141,  +47929,
  77.       +48702,  +49459,  +50202,  +50930,  +51642,  +52338,  +53018,  +53683,
  78.       +54330,  +54962,  +55576,  +56174,  +56754,  +57318,  +57863,  +58392,
  79.       +58902,  +59394,  +59869,  +60325,  +60763,  +61182,  +61582,  +61964,
  80.       +62327,  +62671,  +62996,  +63301,  +63588,  +63855,  +64102,  +64330,
  81.       +64539,  +64728,  +64897,  +65046,  +65175,  +65285,  +65375,  +65445,
  82.       +65495,  +65525
  83. };
  84.  
  85. static long *sintable = &trigtable[0];
  86. static long *costable = &trigtable[90];
  87.  
  88.     /* texture delta values */
  89. #define horiz_delta_u    ( + cost )
  90. #define horiz_delta_v    ( + sint )
  91. #define vert_delta_u    ( - sint )
  92. #define vert_delta_v    ( + cost )
  93.     
  94.     
  95. /*
  96.         calculate the log base 2 of the argument,
  97.         i.e how many bits the number is shifted
  98.         
  99.         return value: is x a power of 2 at all ?
  100. */
  101.  
  102. static Boolean log2(long x,long *bit)
  103. {
  104.     long             i;
  105.     unsigned long    n;
  106.  
  107.     if (x <= 0)
  108.         return false;
  109.     
  110.     n = (unsigned long) x;
  111.      
  112.     for (i = 0; (n & 1) == 0; i++)
  113.     {
  114.         n >>= 1;
  115.     }
  116.     
  117.     if (n == 1)
  118.     {
  119.         *bit = i;        // 1 << i == x
  120.         return true;
  121.     }
  122.     else
  123.         return false;
  124. }
  125.  
  126. #pragma mark -
  127.  
  128. /*****************************************************************************************/
  129.  
  130. void BlitPixieRotoZoom8Bit(
  131.     unsigned char *source,
  132.     unsigned char *dest,
  133.     unsigned long srcBytes,
  134.     unsigned long dstBytes,
  135.     unsigned long width1,
  136.     unsigned long height1,        
  137.     unsigned long width2,
  138.     unsigned long height2,        
  139.     unsigned long angle,
  140.     unsigned long zoom )
  141. {
  142.     long            x,y;                            // loop variables
  143.     register unsigned char    *src,*dst;                // image pointers
  144.     unsigned long    stride;                            // add to go to next row
  145.     long            half_width,half_height;            // half of destination
  146.     long            start_u,start_v;                // starting texel
  147.     long            sint,cost;                        // sine and cosine
  148.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  149.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  150.  
  151.         /* normalize angle and zoom */
  152.     while (angle < 0)        angle += 360;
  153.     while (angle >= 360)    angle -= 360;
  154.  
  155.         /* get look-up values */
  156.     zoom >>= 8;
  157.     sint = (sintable[angle] * (long) zoom) >> 8;
  158.     cost = (costable[angle] * (long) zoom) >> 8;
  159.     
  160.     half_width = width2 >> 1;
  161.     half_height = height2 >> 1;
  162.  
  163.         /* get texture starting values (rotate around center) */
  164.     start_u = (width1 >> 1) << 16;
  165.     start_v = (height1 >> 1) << 16;
  166.     start_u -= cost * half_width - sint * half_height;
  167.     start_v -= sint * half_width + cost * half_height;
  168.     
  169.         /* init pointers & counters */
  170.     src = (unsigned char *) source;
  171.     dst = (unsigned char *) dest;
  172.     stride = (dstBytes - width2);
  173.     
  174.         /* is texture a multiple of 2 ? */
  175.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  176.  
  177.     y = height2;
  178.     
  179.     if (is_shift)
  180.     {
  181.         do
  182.         {
  183.             ul = start_u;    vl = start_v;
  184.  
  185.             for (x = 0; x < width2; x++)
  186.             {    
  187.                 u = ul >> 16;    v = vl >> 16;    
  188.                 
  189.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  190.                     *dst++ = src[(v << shift_x) + u];
  191.                 else
  192.                     ++dst;
  193.             
  194.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  195.             }
  196.             
  197.             start_u += vert_delta_u;    start_v += vert_delta_v;
  198.             
  199.             dst += stride;
  200.         
  201.         } while (--y);
  202.     }
  203.     else
  204.     {
  205.         do
  206.         {
  207.             ul = start_u;    vl = start_v;
  208.  
  209.             for (x = 0; x < width2; x++)
  210.             {    
  211.                 u = ul >> 16;    v = vl >> 16;    
  212.                 
  213.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  214.                     *dst++ = src[(v * srcBytes) + u];
  215.                 else
  216.                     ++dst;
  217.             
  218.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  219.             }
  220.             
  221.             start_u += vert_delta_u;    start_v += vert_delta_v;
  222.             
  223.             dst += stride;
  224.         
  225.         } while (--y);
  226.         
  227.     }
  228.  
  229. }
  230.  
  231. void BlitPixieMaskRotoZoom8Bit(
  232.     unsigned char *source,
  233.     unsigned char *dest,
  234.     unsigned char *maskAddr,
  235.     unsigned long srcBytes,
  236.     unsigned long dstBytes,
  237.     unsigned long width1,
  238.     unsigned long height1,        
  239.     unsigned long width2,
  240.     unsigned long height2,        
  241.     unsigned long angle,
  242.     unsigned long zoom )
  243. {
  244.     long            x,y;                            // loop variables
  245.     register unsigned char    *src,*dst,*mask;        // image pointers
  246.     unsigned long    stride;                            // add to go to next row
  247.     long            half_width,half_height;            // half of destination
  248.     long            start_u,start_v;                // starting texel
  249.     long            sint,cost;                        // sine and cosine
  250.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  251.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  252.  
  253.         /* normalize angle and zoom */
  254.     while (angle < 0)        angle += 360;
  255.     while (angle >= 360)    angle -= 360;
  256.  
  257.         /* get look-up values */
  258.     zoom >>= 8;
  259.     sint = (sintable[angle] * (long) zoom) >> 8;
  260.     cost = (costable[angle] * (long) zoom) >> 8;
  261.     
  262.     half_width = width2 >> 1;
  263.     half_height = height2 >> 1;
  264.  
  265.         /* get texture starting values (rotate around center) */
  266.     start_u = (width1 >> 1) << 16;
  267.     start_v = (height1 >> 1) << 16;
  268.     start_u -= cost * half_width - sint * half_height;
  269.     start_v -= sint * half_width + cost * half_height;
  270.     
  271.         /* init pointers & counters */
  272.     src = (unsigned char *) source;
  273.     mask = (unsigned char *) maskAddr;
  274.     dst = (unsigned char *) dest;
  275.     stride = (dstBytes - width2);
  276.     
  277.         /* is texture a multiple of 2 ? */
  278.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  279.  
  280.     y = height2;
  281.     
  282.     if (is_shift)
  283.     {
  284.         do
  285.         {
  286.             ul = start_u;    vl = start_v;
  287.  
  288.             for (x = 0; x < width2; x++)
  289.             {    
  290.                 u = ul >> 16;    v = vl >> 16;    
  291.                 
  292.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  293.                 {
  294.                     if ( mask[(v << shift_x) + u] == 0 )
  295.                         *dst++ = src[(v << shift_x) + u];
  296.                     else
  297.                         ++dst;
  298.                 }
  299.                 else
  300.                     ++dst;
  301.             
  302.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  303.             }
  304.             
  305.             start_u += vert_delta_u;    start_v += vert_delta_v;
  306.             
  307.             dst += stride;
  308.         
  309.         } while (--y);
  310.     }
  311.     else
  312.     {
  313.         do
  314.         {
  315.             ul = start_u;    vl = start_v;
  316.  
  317.             for (x = 0; x < width2; x++)
  318.             {    
  319.                 u = ul >> 16;    v = vl >> 16;    
  320.                 
  321.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  322.                 {
  323.                     if ( mask[(v * srcBytes) + u] == 0 )
  324.                         *dst++ = src[(v * srcBytes) + u];
  325.                     else
  326.                         ++dst;
  327.                 }
  328.                 else
  329.                     ++dst;
  330.             
  331.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  332.             }
  333.             
  334.             start_u += vert_delta_u;    start_v += vert_delta_v;
  335.             
  336.             dst += stride;
  337.         
  338.         } while (--y);
  339.     }
  340.  
  341. }
  342.  
  343. void BlitPixieRotoZoom16Bit(
  344.     unsigned short *source,
  345.     unsigned short *dest,
  346.     unsigned long srcBytes,
  347.     unsigned long dstBytes,
  348.     unsigned long width1,
  349.     unsigned long height1,        
  350.     unsigned long width2,
  351.     unsigned long height2,        
  352.     unsigned long angle,
  353.     unsigned long zoom )
  354. {
  355.     long            x,y;                            // loop variables
  356.     register unsigned short    *src,*dst;                // image pointers
  357.     unsigned long    stride;                            // add to go to next row
  358.     long            half_width,half_height;            // half of destination
  359.     long            start_u,start_v;                // starting texel
  360.     long            sint,cost;                        // sine and cosine
  361.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  362.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  363.  
  364.         /* normalize angle and zoom */
  365.     while (angle < 0)        angle += 360;
  366.     while (angle >= 360)    angle -= 360;
  367.  
  368.         /* get look-up values */
  369.     zoom >>= 8;
  370.     sint = (sintable[angle] * (long) zoom) >> 8;
  371.     cost = (costable[angle] * (long) zoom) >> 8;
  372.     
  373.     half_width = width2 >> 1;
  374.     half_height = height2 >> 1;
  375.  
  376.         /* get texture starting values (rotate around center) */
  377.     start_u = (width1 >> 1) << 16;
  378.     start_v = (height1 >> 1) << 16;
  379.     start_u -= cost * half_width - sint * half_height;
  380.     start_v -= sint * half_width + cost * half_height;
  381.     
  382.         /* init pointers & counters */
  383.     src = (unsigned short *) source;
  384.     dst = (unsigned short *) dest;
  385.     stride = (dstBytes - width2);
  386.     
  387.         /* is texture a multiple of 2 ? */
  388.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  389.  
  390.     y = height2;
  391.     
  392.     if (is_shift)
  393.     {
  394.         do
  395.         {
  396.             ul = start_u;    vl = start_v;
  397.  
  398.             for (x = 0; x < width2; x++)
  399.             {    
  400.                 u = ul >> 16;    v = vl >> 16;    
  401.                 
  402.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  403.                     *dst++ = src[(v << shift_x) + u];
  404.                 else
  405.                     ++dst;
  406.             
  407.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  408.             }
  409.             
  410.             start_u += vert_delta_u;    start_v += vert_delta_v;
  411.             
  412.             dst += stride;
  413.         
  414.         } while (--y);
  415.     }
  416.     else
  417.     {
  418.         do
  419.         {
  420.             ul = start_u;    vl = start_v;
  421.  
  422.             for (x = 0; x < width2; x++)
  423.             {    
  424.                 u = ul >> 16;    v = vl >> 16;    
  425.                 
  426.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  427.                     *dst++ = src[(v * srcBytes) + u];
  428.                 else
  429.                     ++dst;
  430.             
  431.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  432.             }
  433.             
  434.             start_u += vert_delta_u;    start_v += vert_delta_v;
  435.             
  436.             dst += stride;
  437.         
  438.         } while (--y);
  439.         
  440.     }
  441.  
  442. }
  443.  
  444. void BlitPixieMaskRotoZoom16Bit(
  445.     unsigned short *source,
  446.     unsigned short *dest,
  447.     unsigned short *maskAddr,
  448.     unsigned long srcBytes,
  449.     unsigned long dstBytes,
  450.     unsigned long width1,
  451.     unsigned long height1,        
  452.     unsigned long width2,
  453.     unsigned long height2,        
  454.     unsigned long angle,
  455.     unsigned long zoom )
  456. {
  457.     long            x,y;                            // loop variables
  458.     register unsigned short    *src,*dst,*mask;        // image pointers
  459.     unsigned long    stride;                            // add to go to next row
  460.     long            half_width,half_height;            // half of destination
  461.     long            start_u,start_v;                // starting texel
  462.     long            sint,cost;                        // sine and cosine
  463.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  464.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  465.  
  466.         /* normalize angle and zoom */
  467.     while (angle < 0)        angle += 360;
  468.     while (angle >= 360)    angle -= 360;
  469.  
  470.         /* get look-up values */
  471.     zoom >>= 8;
  472.     sint = (sintable[angle] * (long) zoom) >> 8;
  473.     cost = (costable[angle] * (long) zoom) >> 8;
  474.     
  475.     half_width = width2 >> 1;
  476.     half_height = height2 >> 1;
  477.  
  478.         /* get texture starting values (rotate around center) */
  479.     start_u = (width1 >> 1) << 16;
  480.     start_v = (height1 >> 1) << 16;
  481.     start_u -= cost * half_width - sint * half_height;
  482.     start_v -= sint * half_width + cost * half_height;
  483.     
  484.         /* init pointers & counters */
  485.     src = (unsigned short *) source;
  486.     mask = (unsigned short *) maskAddr;
  487.     dst = (unsigned short *) dest;
  488.     stride = (dstBytes - width2);
  489.     
  490.         /* is texture a multiple of 2 ? */
  491.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  492.  
  493.     y = height2;
  494.     
  495.     if (is_shift)
  496.     {
  497.         do
  498.         {
  499.             ul = start_u;    vl = start_v;
  500.  
  501.             for (x = 0; x < width2; x++)
  502.             {    
  503.                 u = ul >> 16;    v = vl >> 16;    
  504.                 
  505.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  506.                 {
  507.                     if ( mask[(v << shift_x) + u] == 0 )
  508.                         *dst++ = src[(v << shift_x) + u];
  509.                     else
  510.                         ++dst;
  511.                 }
  512.                 else
  513.                     ++dst;
  514.             
  515.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  516.             }
  517.             
  518.             start_u += vert_delta_u;    start_v += vert_delta_v;
  519.             
  520.             dst += stride;
  521.         
  522.         } while (--y);
  523.     }
  524.     else
  525.     {
  526.         do
  527.         {
  528.             ul = start_u;    vl = start_v;
  529.  
  530.             for (x = 0; x < width2; x++)
  531.             {    
  532.                 u = ul >> 16;    v = vl >> 16;    
  533.                 
  534.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  535.                 {
  536.                     if ( mask[(v * srcBytes) + u] == 0 )
  537.                         *dst++ = src[(v * srcBytes) + u];
  538.                     else
  539.                         ++dst;
  540.                 }
  541.                 else
  542.                     ++dst;
  543.             
  544.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  545.             }
  546.             
  547.             start_u += vert_delta_u;    start_v += vert_delta_v;
  548.             
  549.             dst += stride;
  550.         
  551.         } while (--y);
  552.     }
  553.  
  554. }
  555.  
  556. void BlitPixieRotoZoom32Bit(
  557.     unsigned long *source,
  558.     unsigned long *dest,
  559.     unsigned long srcBytes,
  560.     unsigned long dstBytes,
  561.     unsigned long width1,
  562.     unsigned long height1,        
  563.     unsigned long width2,
  564.     unsigned long height2,        
  565.     unsigned long angle,
  566.     unsigned long zoom )
  567. {
  568.     long            x,y;                            // loop variables
  569.     register unsigned long    *src,*dst;                // image pointers
  570.     unsigned long    stride;                            // add to go to next row
  571.     long            half_width,half_height;            // half of destination
  572.     long            start_u,start_v;                // starting texel
  573.     long            sint,cost;                        // sine and cosine
  574.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  575.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  576.  
  577.         /* normalize angle and zoom */
  578.     while (angle < 0)        angle += 360;
  579.     while (angle >= 360)    angle -= 360;
  580.  
  581.         /* get look-up values */
  582.     zoom >>= 8;
  583.     sint = (sintable[angle] * (long) zoom) >> 8;
  584.     cost = (costable[angle] * (long) zoom) >> 8;
  585.     
  586.     half_width = width2 >> 1;
  587.     half_height = height2 >> 1;
  588.  
  589.         /* get texture starting values (rotate around center) */
  590.     start_u = (width1 >> 1) << 16;
  591.     start_v = (height1 >> 1) << 16;
  592.     start_u -= cost * half_width - sint * half_height;
  593.     start_v -= sint * half_width + cost * half_height;
  594.     
  595.         /* init pointers & counters */
  596.     src = (unsigned long *) source;
  597.     dst = (unsigned long *) dest;
  598.     stride = (dstBytes - width2);
  599.     
  600.         /* is texture a multiple of 2 ? */
  601.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  602.  
  603.     y = height2;
  604.     
  605.     if (is_shift)
  606.     {
  607.         do
  608.         {
  609.             ul = start_u;    vl = start_v;
  610.  
  611.             for (x = 0; x < width2; x++)
  612.             {    
  613.                 u = ul >> 16;    v = vl >> 16;    
  614.                 
  615.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  616.                     *dst++ = src[(v << shift_x) + u];
  617.                 else
  618.                     ++dst;
  619.             
  620.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  621.             }
  622.             
  623.             start_u += vert_delta_u;    start_v += vert_delta_v;
  624.             
  625.             dst += stride;
  626.         
  627.         } while (--y);
  628.     }
  629.     else
  630.     {
  631.         do
  632.         {
  633.             ul = start_u;    vl = start_v;
  634.  
  635.             for (x = 0; x < width2; x++)
  636.             {    
  637.                 u = ul >> 16;    v = vl >> 16;    
  638.                 
  639.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  640.                     *dst++ = src[(v * srcBytes) + u];
  641.                 else
  642.                     ++dst;
  643.             
  644.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  645.             }
  646.             
  647.             start_u += vert_delta_u;    start_v += vert_delta_v;
  648.             
  649.             dst += stride;
  650.         
  651.         } while (--y);
  652.         
  653.     }
  654.  
  655. }
  656.  
  657. void BlitPixieMaskRotoZoom32Bit(
  658.     unsigned long *source,
  659.     unsigned long *dest,
  660.     unsigned long *maskAddr,
  661.     unsigned long srcBytes,
  662.     unsigned long dstBytes,
  663.     unsigned long width1,
  664.     unsigned long height1,        
  665.     unsigned long width2,
  666.     unsigned long height2,        
  667.     unsigned long angle,
  668.     unsigned long zoom )
  669. {
  670.     long            x,y;                            // loop variables
  671.     register unsigned long    *src,*dst,*mask;        // image pointers
  672.     unsigned long    stride;                            // add to go to next row
  673.     long            half_width,half_height;            // half of destination
  674.     long            start_u,start_v;                // starting texel
  675.     long            sint,cost;                        // sine and cosine
  676.     unsigned long    u,v,ul,vl;                        // texel, and fixed point texel
  677.     long            is_shift,shift_x,shift_y;        // shift instead of multiply
  678.  
  679.         /* normalize angle and zoom */
  680.     while (angle < 0)        angle += 360;
  681.     while (angle >= 360)    angle -= 360;
  682.  
  683.         /* get look-up values */
  684.     zoom >>= 8;
  685.     sint = (sintable[angle] * (long) zoom) >> 8;
  686.     cost = (costable[angle] * (long) zoom) >> 8;
  687.     
  688.     half_width = width2 >> 1;
  689.     half_height = height2 >> 1;
  690.  
  691.         /* get texture starting values (rotate around center) */
  692.     start_u = (width1 >> 1) << 16;
  693.     start_v = (height1 >> 1) << 16;
  694.     start_u -= cost * half_width - sint * half_height;
  695.     start_v -= sint * half_width + cost * half_height;
  696.     
  697.         /* init pointers & counters */
  698.     src = (unsigned long *) source;
  699.     mask = (unsigned long *) maskAddr;
  700.     dst = (unsigned long *) dest;
  701.     stride = (dstBytes - width2);
  702.     
  703.         /* is texture a multiple of 2 ? */
  704.     is_shift = log2(width1,&shift_x) && log2(height1,&shift_y);
  705.  
  706.     y = height2;
  707.     
  708.     if (is_shift)
  709.     {
  710.         do
  711.         {
  712.             ul = start_u;    vl = start_v;
  713.  
  714.             for (x = 0; x < width2; x++)
  715.             {    
  716.                 u = ul >> 16;    v = vl >> 16;    
  717.                 
  718.                 if (u >= 0 && u < width1 && v > 0 && v < height1 )
  719.                 {
  720.                     if ( mask[(v << shift_x) + u] == 0 )
  721.                         *dst++ = src[(v << shift_x) + u];
  722.                     else
  723.                         ++dst;
  724.                 }
  725.                 else
  726.                     ++dst;
  727.             
  728.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  729.             }
  730.             
  731.             start_u += vert_delta_u;    start_v += vert_delta_v;
  732.             
  733.             dst += stride;
  734.         
  735.         } while (--y);
  736.     }
  737.     else
  738.     {
  739.         do
  740.         {
  741.             ul = start_u;    vl = start_v;
  742.  
  743.             for (x = 0; x < width2; x++)
  744.             {    
  745.                 u = ul >> 16;    v = vl >> 16;    
  746.                 
  747.                 if (u >= 0 && u < width1 && v >= 0 && v < height1 )
  748.                 {
  749.                     if ( mask[(v * srcBytes) + u] == 0 )
  750.                         *dst++ = src[(v * srcBytes) + u];
  751.                     else
  752.                         ++dst;
  753.                 }
  754.                 else
  755.                     ++dst;
  756.             
  757.                 ul += horiz_delta_u;    vl += horiz_delta_v;
  758.             }
  759.             
  760.             start_u += vert_delta_u;    start_v += vert_delta_v;
  761.             
  762.             dst += stride;
  763.         
  764.         } while (--y);
  765.     }
  766.  
  767. }
  768.  
  769. #endif